- Remove `opaque_data` from `skb->cb`, now use TfwClientMem
  instead. Use only default skb destructor to decrement
  client memory when skb is freed.
- Save http2 response in `on_send_data`. Pass NULL (as a conn)
  in `on_send` callback, if appropriate socket is not active or
  conn is real NULL (previously we don't call `on_send` callback
  in such case). Destroy `on_send_data` directly in `on_send`
  callack if we can't send data (conn is NULL).

This patch simplifies the code and makes it consistent with the previous
changes to the `TFW_SKB_CB` structure, which already provides dedicated
storage for data associated with the `on_send` and `on_tcp_entail`
callbacks. Response objects are now stored in this dedicated storage.
This allows us to apply the same approach to requests, allowing them to
be accessed safely from the `on_send_data` and `on_tcp_entail_data`
callbacks.

Part-of: release-server-queued-requests
Issue: #2284

- Rework `on_tcp_entail` callback invocation. Now it is called
  from `ss_skb_tcp_entail_list` not from `ss_skb_tcp_entail`.
  If this callback fails we drop all skbs from appropriate
  list.
- Implement `tfw_http_req_on_tcp_entail` callback to check
  that client connection for sending request is not closed
  and drop skbs and request if connection is already closed.
- Implement `ss_skb_copy_cb` function for correct copying
  of skb->cb (including all callbacks and destructors).

Previously, requests that had already been placed into a server
connection's `fwd_queue` were still forwarded to the server even
after the originating client connection had been closed. Although
the responses to such requests were no longer needed, the requests
themselves were still fully transmitted to the backend.
This patch changes this behavior by performing an additional client
connection state check immediately before entailing a request's skbs
to the server socket write queue for transmission. If the client
connection has already been closed, the request is discarded together
with all associated skbs instead of being sent to the server.
The chosen approach has a theoretical disadvantage: if a large number
of requests from a reset client connection coexist with many requests
from active client connections and the TCP window is small, requests
belonging to the inactive client connection may remain in the server
connection queue for an extended period of time, consuming memory.
An alternative approach would have been to drop the server connection
and purge requests belonging to inactive client connections from the
server send queue during reconnection. This approach was rejected
because it would also impact active client connections by forcing their
requests to be retransmitted.
Since the server connection is also dropped upon receiving the first
response byte for an inactive client connection (see bac89d1), the
current implementation provides a practical and effective fix for
issue #2284.

Part-of: release-server-queued-requests
Closes #2284

Previously there was a sofisticated logic in
`ss_skb_tcp_entail_list` function, which we are
planning to use to handle ENOMEM in a special way
and do not drop connection. Since we decide to
don't do it, remove this logic at all.
(Made here since we already change `ss_skb_tcp_entail_list`
 in this PR).

- Remove unnecessary `skb_copy_cb` (`__pskb_copy_fclone` already
  do it). Instead of it zero all fields for the cloned skb, which
  are related to client memory accounting (since we set client
  memory for the new cloned skb manually). Zero all other fields
  for original skb, we need appropriate callbacks only for skbs,
  which we will send to the socket write queue.
- Move `ss_skb_on_tcp_entail` under `if (TFW_SKB_CB(skb)->is_head)`
  to show that it should be called only to the head of the list.
- Add comments.
- introduce skb callback container. There are currently many cases
  where different callbacks are required for request/response and
  HTTP/2 frame sending. Since the space available in `skb->cb` is
  limited, introduce a callback container structure and store a
  pointer to it in `skb->cb` instead of embedding callback-specific
  data directly. In addition to improving code clarity and freeing
  space in skb->cb, this change allows an unlimited number of callbacks
  to be added in the future.

Since now we use only default skb destructor for
client memory adjusting, we can remove appropriate
pointer from `skb->cb` and save 8 bytes.

During making frames we adjust skb length to recalculate
`snd_wnd`. It seems when we send http1 data, it's better
to work in the same way. (Made here since we already
change `ss_skb_tcp_entail_list` in this PR).

Use pool-based approach for HTTP/2 to HTTP/1 request transformation.
- Reuse the same pool-based approach already used for HTTP/1 request
  forwarding, providing a unified implementation.
- Eliminate extra header copying. Previously, headers were written into
  the linear skb area and then copied by `_pskb_copy_fclone`. Now headers
  are written directly into skb fragments, reducing memory usage and copy
  overhead.
- do not allocate a new skb during http1 request/response preparing. We
  should remove all old skbs except skb_head. In `skb_head` we can remove
  all fragments and linear data and reuse it, instead of new skb allocation.

This patch demonstrate a very good performance improvement for big requests
without cache:
2284:
finished in 50.04s, 330629.14 req/s, 202.22MB/s
finished in 50.04s, 328837.60 req/s, 201.04MB/s
finished in 50.04s, 329637.96 req/s, 201.61MB/s
master:
finished in 50.04s, 328963.94 req/s, 201.21MB/s
finished in 50.06s, 329731.98 req/s, 201.58MB/s
finished in 50.04s, 328985.10 req/s, 201.17MB/s

2284 2K:
finished in 50.04s, 330025.50 req/s, 201.98MB/s
finished in 50.04s, 329206.90 req/s, 201.32MB/s
finished in 50.04s, 329906.58 req/s, 201.74MB/s
master 2K:
finished in 50.03s, 277741.36 req/s, 169.92MB/s
finished in 50.03s, 294516.36 req/s, 180.08MB/s
finished in 50.03s, 298020.96 req/s, 182.21MB/s

2284 4k:
finished in 50.03s, 313275.10 req/s, 191.66MB/s
finished in 50.03s, 313052.38 req/s, 191.45MB/s
finished in 50.03s, 304237.44 req/s, 186.14MB/s
master 4K:
finished in 50.03s, 261815.08 req/s, 160.15MB/s
finished in 50.03s, 273399.16 req/s, 167.18MB/s
finished in 50.03s, 270743.96 req/s, 165.64MB/s

This patch is also important in the context of fixing issue #2284.
As described earlier, when a large number of requests from a reset
client connection coexist with requests from active client connections
and the TCP window is small, requests belonging to inactive client
connections may remain queued on the server connection for an extended
period of time, consuming memory. This patch significantly reduce this
memory overhead. Previously, request headers were stored in the skb
linear data and were copied during `_pskb_copy_fclone` (doubling memory
consumption!) Request headers are now stored in skb fragments instead,
avoiding the copy in `_pskb_copy_fclone` and reducing memory usage by
approximately 50%.

Remove `ss_skb_dflt_destructor` - this function
is currently used only in one place. Additionally,
the function name does not accurately reflect its
behavior.